class BT_NODE{ KEY < $IS_LT{KEY}, ELT } < $BT_NODE{KEY,ELT,BT_NODE{KEY,ELT}}


Ancestors
$BT_NODE{_,_,_} AREF{_}

Descendants
BT_NODE_DBG{_,_}



Public


Readable Attributes
attr size: INT;
**** Current fill ratio of the node.

Writable Attributes
attr size: INT;
**** Current fill ratio of the node.

Constants
const maxSize: INT := 4;
**** maximal number of elt tuples. MUST BE EVEN AND GREATER THAN 2.
const minSize: INT := maxSize / 2;

Features
aclear .. Included as aclear
**** Set each element of self to nil. Built-in.
acopy(src:SAME) .. Included as acopy
**** Copy as many elements from `src' to self as will fit. Built-in.
acopy(beg:INT, src:SAME) .. Included as acopy
**** Copy as many elements from `src' to self as will fit when starting at index `beg' of self.
acopy(beg,num:INT, src:SAME) .. Included as acopy
**** Copy `num' elements from `src' to self starting at index `beg' of self.
acopy(beg,num,srcbeg:INT, src:SAME) .. Included as acopy
**** Copy `num' elements from `src' to self starting at index `beg' of self and index `srcbeg' of `src'. Built-in.
aget(ind:INT):T .. Included as aget
**** The element of self with index `ind'. Built-in.
array_ptr:C_PTR .. Included as array_ptr
asize:INT .. Included as asize
**** The number of elements in self. Classes which inherit this may replace this by a constant to get constant sized objects (and the compiler may optimize certain operations in this case). Built-in.
create(n:INT):SAME .. Included as create
**** A new array with `n' elements.
create( t: TUP{KEY,ELT} ): SAME
create: SAME
find( k: KEY, stack: A_STACK{TUP{INT,SAME}} ): BOOL
findPred( stack: A_STACK{TUP{INT,SAME}} )
is_eq( n: SAME ): BOOL
joinLeft( pos: INT, stack: A_STACK{TUP{INT,SAME}} )
joinRight( pos: INT, stack: A_STACK{TUP{INT,SAME}} )
leftFree( stack: A_STACK{TUP{INT,SAME}} ): BOOL
leftSpare( stack: A_STACK{TUP{INT,SAME}} ): BOOL
nodeDelete( pos: INT )
nodeInsert( n: SAME, pos: INT )
pullLeft( pos: INT, stack: A_STACK{TUP{INT,SAME}} )
pullRight( pos: INT, stack: A_STACK{TUP{INT,SAME}} )
pushLeft( e: SAME, pos: INT, stack: A_STACK{TUP{INT,SAME}} )
pushRight( e: SAME, pos: INT, stack: A_STACK{TUP{INT,SAME}} )
rightFree( stack: A_STACK{TUP{INT,SAME}} ): BOOL
rightSpare( stack: A_STACK{TUP{INT,SAME}} ): BOOL
setItem( pos: INT, t: TUP{KEY,ELT} )
setNode( pos: INT, node: SAME )
split( e: SAME, pos: INT ): SAME

Iters
aelt!(once beg:INT):T .. Included as aelt!
**** Yield each element of self starting at `beg'. Built-in.
aelt!(once beg,once num:INT):T .. Included as aelt!
**** Yield `num' successive elements of self starting at index `beg'. Built-in.
aelt!(once beg,once num,once step:INT):T .. Included as aelt!
**** Yield `num' elements of self starting at `beg' and stepping by `step' which must not be zero. Built-in.
aelt!:T .. Included as aelt!
**** Yield each element of self in order. Built-in.
aind!:INT .. Included as aind!
**** Yield the indices of self in order.
aset!(val:T) .. Included as aset!
**** Set successive elements of self to the values `val'. Built-in.
aset!(once beg:INT,val:T) .. Included as aset!
**** Set successive elements of self starting at `beg' to the values `val'.
aset!(once beg,once num:INT,val:T) .. Included as aset!
**** Set `num' successive elements of self starting at `beg' to the values `val'.
aset!(once beg,once num,once step:INT, val:T) .. Included as aset!
**** Set `num' elements of self starting at `beg' stepping by `step' to the values `val'. `step' must not be zero.
elt!: ELT
ind!: KEY
pair!: TUP{KEY,ELT}


Private

aset(ind:INT, val:T) .. Included as aset
**** Set the element of self with index `ind' to `val'. Built-in.
is_legal_aelts_arg( beg, num, step:INT) :BOOL .. Included as is_legal_aelts_arg
**** True if the arguments are legal values for `aelts'.

The Sather Home Page